﻿using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text.RegularExpressions;
using UnityEngine;

namespace Studio
{
	// Token: 0x020004DB RID: 1243
	public class Info : Singleton<Info>
	{
		// Token: 0x170003A1 RID: 929
		// (get) Token: 0x06001FB7 RID: 8119 RVA: 0x000C46EC File Offset: 0x000C28EC
		public ExcelData accessoryPoint
		{
			get
			{
				return this.m_AccessoryPoint;
			}
		}

		// Token: 0x170003A2 RID: 930
		// (get) Token: 0x06001FB8 RID: 8120 RVA: 0x000C46F4 File Offset: 0x000C28F4
		public ExcelData accessoryPointGroup
		{
			get
			{
				return this.m_AccessoryPointGroup;
			}
		}

		// Token: 0x170003A3 RID: 931
		// (get) Token: 0x06001FB9 RID: 8121 RVA: 0x000C46FC File Offset: 0x000C28FC
		// (set) Token: 0x06001FBA RID: 8122 RVA: 0x000C4704 File Offset: 0x000C2904
		public bool isLoadList { get; private set; }

		// Token: 0x06001FBB RID: 8123 RVA: 0x000C4710 File Offset: 0x000C2910
		public IEnumerator LoadExcelDataCoroutine()
		{
			if (this.isLoadList)
			{
				yield break;
			}
			this.fileCheck = new Info.FileCheck();
			this.waitTime = new Info.WaitTime();
			this.dicFemaleBoneInfo.Clear();
			this.dicMaleBoneInfo.Clear();
			this.dicItemGroup.Clear();
			this.dicItemLoadInfo.Clear();
			this.dicHItemLoadInfo.Clear();
			this.dicLightLoadInfo.Clear();
			this.dicFAGroupCategory.Clear();
			this.dicFemaleAnimeLoadInfo.Clear();
			this.dicMAGroupCategory.Clear();
			this.dicMaleAnimeLoadInfo.Clear();
			this.dicFemaleHandAnime[0].Clear();
			this.dicFemaleHandAnime[1].Clear();
			this.dicMaleHandAnime[0].Clear();
			this.dicMaleHandAnime[1].Clear();
			this.dicVoiceGroupCategory.Clear();
			this.dicVoiceLoadInfo.Clear();
			if (this.waitTime.isOver)
			{
				yield return null;
				this.waitTime.Next();
			}
			this.m_AccessoryPoint = this.LoadExcelData("studio/info/00.unity3d", "AccessoryPoint_00");
			this.m_AccessoryPointGroup = this.LoadExcelData("studio/info/00.unity3d", "AccessoryPointGroup_00");
			List<string> pathList = CommonLib.GetAssetBundleNameListFromPath("studio/info/", true);
			pathList.Sort();
			if (this.waitTime.isOver)
			{
				yield return null;
				this.waitTime.Next();
			}
			for (int i = 0; i < pathList.Count; i++)
			{
				string bundlePath = pathList[i];
				string fileName = Path.GetFileNameWithoutExtension(bundlePath);
				this.LoadBoneInfo(this.LoadExcelData(bundlePath, "FemaleBone_" + fileName), this.dicFemaleBoneInfo);
				if (this.waitTime.isOver)
				{
					yield return null;
					this.waitTime.Next();
				}
				this.LoadBoneInfo(this.LoadExcelData(bundlePath, "MaleBone_" + fileName), this.dicMaleBoneInfo);
				if (this.waitTime.isOver)
				{
					yield return null;
					this.waitTime.Next();
				}
				this.LoadItemCategoryInfo(this.LoadExcelData(bundlePath, "ItemGroup_" + fileName));
				if (this.waitTime.isOver)
				{
					yield return null;
					this.waitTime.Next();
				}
				this.LoadItemLoadInfo(bundlePath, "ItemList_(\\d*)_(\\d*)");
				if (this.waitTime.isOver)
				{
					yield return null;
					this.waitTime.Next();
				}
				this.LoadItemBoneInfo(bundlePath, "ItemBoneList_(\\d*)_(\\d*)");
				if (this.waitTime.isOver)
				{
					yield return null;
					this.waitTime.Next();
				}
				this.LoadAnimeGroupInfo(this.LoadExcelData(bundlePath, "FemaleAnimeGroup_" + fileName), this.dicFAGroupCategory);
				if (this.waitTime.isOver)
				{
					yield return null;
					this.waitTime.Next();
				}
				this.LoadAnimeCategoryInfo(bundlePath, "FemaleAnimeCategory_(\\d*)_(\\d*)", this.dicFAGroupCategory);
				if (this.waitTime.isOver)
				{
					yield return null;
					this.waitTime.Next();
				}
				yield return this.LoadAnimeLoadInfoCoroutine(bundlePath, "FemaleAnime_(\\d*)_(\\d*)_(\\d*)", this.dicFemaleAnimeLoadInfo, new Info.LoadAnimeInfoCoroutineFunc(this.LoadAnimeLoadInfo));
				yield return this.LoadAnimeLoadInfoCoroutine(bundlePath, "FemaleHAnime_(\\d*)_(\\d*)_(\\d*)", this.dicFemaleAnimeLoadInfo, new Info.LoadAnimeInfoCoroutineFunc(this.LoadHAnimeLoadInfo));
				this.LoadHandAnimeInfo(bundlePath, "FemaleHandAnime_(\\d*)_(\\d*)", this.dicFemaleHandAnime);
				if (this.waitTime.isOver)
				{
					yield return null;
					this.waitTime.Next();
				}
				this.LoadAnimeGroupInfo(this.LoadExcelData(bundlePath, "MaleAnimeGroup_" + fileName), this.dicMAGroupCategory);
				if (this.waitTime.isOver)
				{
					yield return null;
					this.waitTime.Next();
				}
				this.LoadAnimeCategoryInfo(bundlePath, "MaleAnimeCategory_(\\d*)_(\\d*)", this.dicMAGroupCategory);
				if (this.waitTime.isOver)
				{
					yield return null;
					this.waitTime.Next();
				}
				yield return this.LoadAnimeLoadInfoCoroutine(bundlePath, "MaleAnime_(\\d*)_(\\d*)_(\\d*)", this.dicMaleAnimeLoadInfo, new Info.LoadAnimeInfoCoroutineFunc(this.LoadAnimeLoadInfo));
				yield return this.LoadAnimeLoadInfoCoroutine(bundlePath, "MaleHAnime_(\\d*)_(\\d*)_(\\d*)", this.dicMaleAnimeLoadInfo, new Info.LoadAnimeInfoCoroutineFunc(this.LoadHAnimeLoadInfo));
				this.LoadHandAnimeInfo(bundlePath, "MaleHandAnime_(\\d*)_(\\d*)", this.dicMaleHandAnime);
				if (this.waitTime.isOver)
				{
					yield return null;
					this.waitTime.Next();
				}
				this.LoadAnimeGroupInfo(this.LoadExcelData(bundlePath, "VoiceGroup_" + fileName), this.dicVoiceGroupCategory);
				if (this.waitTime.isOver)
				{
					yield return null;
					this.waitTime.Next();
				}
				this.LoadAnimeCategoryInfo(bundlePath, "VoiceCategory_(\\d*)_(\\d*)", this.dicVoiceGroupCategory);
				if (this.waitTime.isOver)
				{
					yield return null;
					this.waitTime.Next();
				}
				yield return this.LoadVoiceLoadInfoCoroutine(bundlePath, "Voice_(\\d*)_(\\d*)_(\\d*)");
				this.LoadSoundLoadInfo(this.LoadExcelData(bundlePath, "BGM_" + fileName), this.dicBGMLoadInfo);
				if (this.waitTime.isOver)
				{
					yield return null;
					this.waitTime.Next();
				}
				this.LoadMapLoadInfo(this.LoadExcelData(bundlePath, "Map_" + fileName), this.dicMapLoadInfo);
				if (this.waitTime.isOver)
				{
					yield return null;
					this.waitTime.Next();
				}
				string[] str = new string[]
				{
					"FemaleEye_" + fileName,
					"FemaleMouth_" + fileName,
					"MaleEye_" + fileName,
					"MaleMouth_" + fileName
				};
				Dictionary<int, Info.ExpressionInfo>[] dic = new Dictionary<int, Info.ExpressionInfo>[]
				{
					this.dicFemaleEye,
					this.dicFemaleMouth,
					this.dicMaleEye,
					this.dicMaleMouth
				};
				for (int j = 0; j < str.Length; j++)
				{
					this.LoadExpressionInfo(this.LoadExcelData(bundlePath, str[j]), dic[j]);
					if (this.waitTime.isOver)
					{
						yield return null;
						this.waitTime.Next();
					}
				}
				this.LoadSkyLoadInfo(this.LoadExcelData(bundlePath, "Skybox_" + fileName), this.dicSkyLoadInfo);
				if (this.waitTime.isOver)
				{
					yield return null;
					this.waitTime.Next();
				}
				AssetBundleManager.UnloadAssetBundle(bundlePath, true, null, false);
			}
			this.fileCheck = null;
			this.waitTime = null;
			this.isLoadList = true;
			yield break;
		}

		// Token: 0x06001FBC RID: 8124 RVA: 0x000C472C File Offset: 0x000C292C
		public Info.LoadCommonInfo GetVoiceInfo(int _group, int _category, int _no)
		{
			Dictionary<int, Dictionary<int, Info.LoadCommonInfo>> dictionary = null;
			if (!this.dicVoiceLoadInfo.TryGetValue(_group, out dictionary))
			{
				return null;
			}
			Dictionary<int, Info.LoadCommonInfo> dictionary2 = null;
			if (!dictionary.TryGetValue(_category, out dictionary2))
			{
				return null;
			}
			Info.LoadCommonInfo loadCommonInfo = null;
			return (!dictionary2.TryGetValue(_no, out loadCommonInfo)) ? null : loadCommonInfo;
		}

		// Token: 0x06001FBD RID: 8125 RVA: 0x000C477C File Offset: 0x000C297C
		private ExcelData LoadExcelData(string _bundlePath, string _fileName)
		{
			string text = string.Empty;
			if (AssetBundleCheck.IsSimulation)
			{
				if (!AssetBundleCheck.FindFile(_bundlePath, _fileName, false))
				{
					return null;
				}
			}
			else
			{
				bool flag = false;
				foreach (KeyValuePair<string, AssetBundleManager.BundlePack> keyValuePair in from v in AssetBundleManager.ManifestBundlePack
				where Regex.Match(v.Key, "studio(\\d*)").Success
				select v)
				{
					flag |= (keyValuePair.Value.AssetBundleManifest.GetAllAssetBundles().ToList<string>().FindIndex((string s) => s == _bundlePath) != -1);
					if (flag)
					{
						text = keyValuePair.Key;
						break;
					}
				}
				if (!flag)
				{
					return null;
				}
			}
			string bundlePath = _bundlePath;
			string manifestName = text;
			ExcelData excelData = CommonLib.LoadAsset<ExcelData>(bundlePath, _fileName, false, manifestName);
			if (null == excelData)
			{
				return null;
			}
			return excelData;
		}

		// Token: 0x06001FBE RID: 8126 RVA: 0x000C48A4 File Offset: 0x000C2AA4
		private Info.ItemLoadInfo LoadItemLoadInfo(List<string> _list)
		{
			int num = 0;
			Info.ItemLoadInfo itemLoadInfo = new Info.ItemLoadInfo();
			if (!int.TryParse(_list[num++], out itemLoadInfo.no))
			{
				return null;
			}
			itemLoadInfo.group = int.Parse(_list[num++]);
			itemLoadInfo.name = _list[num++];
			itemLoadInfo.manifest = _list[num++];
			itemLoadInfo.bundlePath = _list[num++];
			itemLoadInfo.fileName = _list[num++];
			itemLoadInfo.childRoot = _list[num++];
			itemLoadInfo.isAnime = bool.Parse(_list[num++]);
			itemLoadInfo.isColor = bool.Parse(_list[num++]);
			itemLoadInfo.colorTarget = _list[num++].Split(new char[]
			{
				'/'
			});
			itemLoadInfo.isColor2 = bool.Parse(_list[num++]);
			itemLoadInfo.color2Target = ((!itemLoadInfo.isColor2) ? null : _list[num++].Split(new char[]
			{
				'/'
			}));
			if (!itemLoadInfo.isColor2)
			{
				num++;
			}
			itemLoadInfo.isScale = bool.Parse(_list[num++]);
			this.dicItemLoadInfo[itemLoadInfo.no] = itemLoadInfo;
			return itemLoadInfo;
		}

		// Token: 0x06001FBF RID: 8127 RVA: 0x000C4A10 File Offset: 0x000C2C10
		private Info.ItemLoadInfo LoadHItemLoadInfo(List<string> _list)
		{
			int num = 0;
			Info.ItemLoadInfo itemLoadInfo = new Info.ItemLoadInfo
			{
				group = -1,
				childRoot = string.Empty,
				isAnime = false,
				isColor = false,
				isColor2 = false,
				isScale = false
			};
			itemLoadInfo.no = int.Parse(_list[num++]);
			itemLoadInfo.name = _list[num++];
			itemLoadInfo.manifest = _list[num++];
			itemLoadInfo.bundlePath = _list[num++];
			itemLoadInfo.fileName = _list[num++];
			this.dicHItemLoadInfo[itemLoadInfo.no] = itemLoadInfo;
			return itemLoadInfo;
		}

		// Token: 0x06001FC0 RID: 8128 RVA: 0x000C4AC4 File Offset: 0x000C2CC4
		private Info.ParentageInfo[] AnalysisParentageInfo(string _str)
		{
			string[] array = _str.Split(new char[]
			{
				','
			});
			List<Info.ParentageInfo> list = new List<Info.ParentageInfo>();
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(new char[]
				{
					'/'
				});
				Info.ParentageInfo parentageInfo = new Info.ParentageInfo();
				parentageInfo.parent = array2[0];
				if (array2.Length > 1)
				{
					parentageInfo.child = array2[1];
				}
				list.Add(parentageInfo);
			}
			return list.ToArray();
		}

		// Token: 0x06001FC1 RID: 8129 RVA: 0x000C4B44 File Offset: 0x000C2D44
		private Info.LoadCommonInfo LoadVoiceLoadInfo(List<string> _list)
		{
			int num = 0;
			Info.LoadCommonInfo loadCommonInfo = new Info.LoadCommonInfo();
			int key = -1;
			if (!int.TryParse(_list[num++], out key))
			{
				return null;
			}
			int key2 = -1;
			if (!int.TryParse(_list[num++], out key2))
			{
				return null;
			}
			int key3 = -1;
			if (!int.TryParse(_list[num++], out key3))
			{
				return null;
			}
			loadCommonInfo.name = _list[num++];
			loadCommonInfo.bundlePath = _list[num++];
			loadCommonInfo.fileName = _list[num++];
			if (!this.dicVoiceLoadInfo.ContainsKey(key2))
			{
				this.dicVoiceLoadInfo.Add(key2, new Dictionary<int, Dictionary<int, Info.LoadCommonInfo>>());
			}
			if (!this.dicVoiceLoadInfo[key2].ContainsKey(key3))
			{
				this.dicVoiceLoadInfo[key2].Add(key3, new Dictionary<int, Info.LoadCommonInfo>());
			}
			this.dicVoiceLoadInfo[key2][key3][key] = loadCommonInfo;
			return loadCommonInfo;
		}

		// Token: 0x06001FC2 RID: 8130 RVA: 0x000C4C4C File Offset: 0x000C2E4C
		private string[] FindAllAssetName(string _bundlePath, string _regex)
		{
			string[] result = null;
			if (AssetBundleCheck.IsSimulation)
			{
				result = AssetBundleCheck.FindAllAssetName(_bundlePath, _regex, false, RegexOptions.IgnoreCase);
			}
			else
			{
				foreach (KeyValuePair<string, AssetBundleManager.BundlePack> keyValuePair in from v in AssetBundleManager.ManifestBundlePack
				where Regex.Match(v.Key, "studio(\\d*)").Success
				select v)
				{
					if (keyValuePair.Value.AssetBundleManifest.GetAllAssetBundles().ToList<string>().FindIndex((string s) => s == _bundlePath) != -1)
					{
						LoadedAssetBundle loadedAssetBundle = null;
						if (!keyValuePair.Value.LoadedAssetBundles.TryGetValue(_bundlePath, out loadedAssetBundle))
						{
							break;
						}
						IEnumerable<string> allAssetNames = loadedAssetBundle.m_AssetBundle.GetAllAssetNames();
						if (Info.callback0 == null)
						{
							Info.callback0 = new Func<string, string>(Path.GetFileNameWithoutExtension);
						}
						result = allAssetNames.Select(Info.callback0).Where((string s) => Regex.Match(s, _regex, RegexOptions.IgnoreCase).Success).ToArray<string>();
						loadedAssetBundle = null;
						break;
					}
				}
			}
			return result;
		}

		// Token: 0x06001FC3 RID: 8131 RVA: 0x000C4DA0 File Offset: 0x000C2FA0
		private void LoadBoneInfo(ExcelData _ed, Dictionary<int, Info.BoneInfo> _dic)
		{
			if (_ed == null)
			{
				return;
			}
			foreach (List<string> list in from v in _ed.list.Skip(1)
			select v.list)
			{
				int num = 0;
				int num2 = -1;
				if (int.TryParse(list[num++], out num2))
				{
					string text = list[num++];
					if (!text.IsNullOrEmpty())
					{
						_dic[num2] = new Info.BoneInfo
						{
							no = num2,
							bone = text,
							name = list[num++],
							group = int.Parse(list[num++]),
							level = int.Parse(list[num++])
						};
					}
				}
			}
		}

		// Token: 0x06001FC4 RID: 8132 RVA: 0x000C4EC8 File Offset: 0x000C30C8
		private void LoadItemCategoryInfo(ExcelData _ed)
		{
			if (_ed == null)
			{
				return;
			}
			foreach (List<string> list in from v in _ed.list.Skip(1)
			select v.list)
			{
				int key = int.Parse(list[0]);
				string value = list[1];
				this.dicItemGroup[key] = value;
			}
		}

		// Token: 0x06001FC5 RID: 8133 RVA: 0x000C4F74 File Offset: 0x000C3174
		private void LoadItemLoadInfo(string _bundlePath, string _regex)
		{
			string[] array = this.FindAllAssetName(_bundlePath, _regex);
			if (array.IsNullOrEmpty<string>())
			{
				return;
			}
			SortedDictionary<int, SortedDictionary<int, string>> sortedDictionary = new SortedDictionary<int, SortedDictionary<int, string>>();
			this.SortDictionary(array, _regex, sortedDictionary);
			foreach (KeyValuePair<int, SortedDictionary<int, string>> keyValuePair in sortedDictionary)
			{
				foreach (KeyValuePair<int, string> keyValuePair2 in keyValuePair.Value)
				{
					this.LoadItemLoadInfo(this.LoadExcelData(_bundlePath, keyValuePair2.Value));
				}
			}
		}

		// Token: 0x06001FC6 RID: 8134 RVA: 0x000C5044 File Offset: 0x000C3244
		private void SortDictionary(string[] files, string _regex, SortedDictionary<int, SortedDictionary<int, string>> _sortDic)
		{
			string strB = _regex.Split(new char[]
			{
				'_'
			})[0].ToLower();
			for (int i = 0; i < files.Length; i++)
			{
				if (files[i].Split(new char[]
				{
					'_'
				})[0].ToLower().CompareTo(strB) == 0)
				{
					Match match = Regex.Match(files[i], _regex, RegexOptions.IgnoreCase);
					int key = int.Parse(match.Groups[1].Value);
					int key2 = int.Parse(match.Groups[2].Value);
					if (!_sortDic.ContainsKey(key))
					{
						_sortDic.Add(key, new SortedDictionary<int, string>());
					}
					_sortDic[key].Add(key2, files[i]);
				}
			}
		}

		// Token: 0x06001FC7 RID: 8135 RVA: 0x000C510C File Offset: 0x000C330C
		private void LoadItemLoadInfo(ExcelData _ed)
		{
			if (_ed == null)
			{
				return;
			}
			foreach (List<string> list in from v in _ed.list.Skip(1)
			select v.list)
			{
				if (list.Count >= 13)
				{
					this.LoadItemLoadInfo(list);
				}
			}
		}

		// Token: 0x06001FC8 RID: 8136 RVA: 0x000C51B0 File Offset: 0x000C33B0
		private void LoadItemBoneInfo(string _bundlePath, string _regex)
		{
			string[] array = this.FindAllAssetName(_bundlePath, _regex);
			if (array.IsNullOrEmpty<string>())
			{
				return;
			}
			SortedDictionary<int, SortedDictionary<int, string>> sortedDictionary = new SortedDictionary<int, SortedDictionary<int, string>>();
			this.SortDictionary(array, _regex, sortedDictionary);
			foreach (KeyValuePair<int, SortedDictionary<int, string>> keyValuePair in sortedDictionary)
			{
				foreach (KeyValuePair<int, string> keyValuePair2 in keyValuePair.Value)
				{
					this.LoadItemBoneInfo(this.LoadExcelData(_bundlePath, keyValuePair2.Value));
				}
			}
		}

		// Token: 0x06001FC9 RID: 8137 RVA: 0x000C5280 File Offset: 0x000C3480
		private void LoadItemBoneInfo(ExcelData _ed)
		{
			if (_ed == null)
			{
				return;
			}
			foreach (List<string> list in from v in _ed.list.Skip(1)
			select v.list)
			{
				Info.ItemLoadInfo itemLoadInfo = null;
				int key = int.Parse(list[0]);
				if (this.dicItemLoadInfo.TryGetValue(key, out itemLoadInfo))
				{
					itemLoadInfo.bones = list.Skip(1).Where((string s) => !s.IsNullOrEmpty()).ToList<string>();
				}
			}
		}

		// Token: 0x06001FCA RID: 8138 RVA: 0x000C5364 File Offset: 0x000C3564
		private IEnumerator LoadHItemLoadInfoCoroutine(ExcelData _ed)
		{
			if (_ed == null)
			{
				yield break;
			}
			foreach (List<string> i in from v in _ed.list.Skip(1)
			select v.list)
			{
				if (this.waitTime.isOver)
				{
					yield return null;
					this.waitTime.Next();
				}
				this.LoadHItemLoadInfo(i);
			}
			yield break;
		}

		// Token: 0x06001FCB RID: 8139 RVA: 0x000C5388 File Offset: 0x000C3588
		private IEnumerator LoadLightLoadInfoCoroutine(ExcelData _ed)
		{
			if (_ed == null)
			{
				yield break;
			}
			int numR = _ed.list.Count;
			for (int r = 1; r < numR; r++)
			{
				if (this.waitTime.isOver)
				{
					yield return null;
					this.waitTime.Next();
				}
				ExcelData.Param param = _ed.list[r];
				int idx = 0;
				Info.LightLoadInfo info = new Info.LightLoadInfo();
				Info.LightLoadInfo lightLoadInfo = info;
				List<string> list = param.list;
				int index;
				idx = (index = idx) + 1;
				lightLoadInfo.no = int.Parse(list[index]);
				Info.LoadCommonInfo loadCommonInfo = info;
				List<string> list2 = param.list;
				idx = (index = idx) + 1;
				loadCommonInfo.name = list2[index];
				Info.FileInfo fileInfo = info;
				List<string> list3 = param.list;
				idx = (index = idx) + 1;
				fileInfo.manifest = list3[index];
				Info.FileInfo fileInfo2 = info;
				List<string> list4 = param.list;
				idx = (index = idx) + 1;
				fileInfo2.bundlePath = list4[index];
				Info.FileInfo fileInfo3 = info;
				List<string> list5 = param.list;
				idx = (index = idx) + 1;
				fileInfo3.fileName = list5[index];
				Info.LightLoadInfo lightLoadInfo2 = info;
				List<string> list6 = param.list;
				idx = (index = idx) + 1;
				lightLoadInfo2.target = (Info.LightLoadInfo.Target)int.Parse(list6[index]);
				this.dicLightLoadInfo[info.no] = info;
			}
			yield break;
		}

		// Token: 0x06001FCC RID: 8140 RVA: 0x000C53AC File Offset: 0x000C35AC
		private void LoadAnimeGroupInfo(ExcelData _ed, Dictionary<int, Info.GroupInfo> _dic)
		{
			if (_ed == null)
			{
				return;
			}
			foreach (List<string> list in from v in _ed.list.Skip(1)
			select v.list)
			{
				int key = int.Parse(list[0]);
				string name = list[1];
				Info.GroupInfo groupInfo = null;
				if (_dic.TryGetValue(key, out groupInfo))
				{
					groupInfo.name = name;
				}
				else
				{
					groupInfo = new Info.GroupInfo();
					groupInfo.name = name;
					_dic.Add(key, groupInfo);
				}
			}
		}

		// Token: 0x06001FCD RID: 8141 RVA: 0x000C5480 File Offset: 0x000C3680
		private void LoadAnimeCategoryInfo(string _bundlePath, string _regex, Dictionary<int, Info.GroupInfo> _dic)
		{
			string[] array = this.FindAllAssetName(_bundlePath, _regex);
			if (array.IsNullOrEmpty<string>())
			{
				return;
			}
			string strB = _regex.Split(new char[]
			{
				'_'
			})[0].ToLower();
			SortedDictionary<int, SortedDictionary<int, string>> sortedDictionary = new SortedDictionary<int, SortedDictionary<int, string>>();
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i].Split(new char[]
				{
					'_'
				})[0].ToLower().CompareTo(strB) == 0)
				{
					Match match = Regex.Match(array[i], _regex, RegexOptions.IgnoreCase);
					int key = int.Parse(match.Groups[1].Value);
					int key2 = int.Parse(match.Groups[2].Value);
					if (!sortedDictionary.ContainsKey(key))
					{
						sortedDictionary.Add(key, new SortedDictionary<int, string>());
					}
					sortedDictionary[key].Add(key2, array[i]);
				}
			}
			foreach (KeyValuePair<int, SortedDictionary<int, string>> keyValuePair in sortedDictionary)
			{
				if (_dic.ContainsKey(keyValuePair.Key))
				{
					foreach (KeyValuePair<int, string> keyValuePair2 in keyValuePair.Value)
					{
						this.LoadAnimeCategoryInfo(this.LoadExcelData(_bundlePath, keyValuePair2.Value), _dic[keyValuePair.Key]);
					}
				}
			}
		}

		// Token: 0x06001FCE RID: 8142 RVA: 0x000C5630 File Offset: 0x000C3830
		private void LoadAnimeCategoryInfo(ExcelData _ed, Info.GroupInfo _info)
		{
			if (_ed == null)
			{
				return;
			}
			foreach (List<string> list in from v in _ed.list.Skip(1)
			select v.list)
			{
				int key = -1;
				if (int.TryParse(list[0], out key))
				{
					_info.dicCategory[key] = list[1];
				}
			}
		}

		// Token: 0x06001FCF RID: 8143 RVA: 0x000C56E4 File Offset: 0x000C38E4
		private IEnumerator LoadAnimeLoadInfoCoroutine(string _bundlePath, string _regex, Dictionary<int, Dictionary<int, Dictionary<int, Info.AnimeLoadInfo>>> _dic, Info.LoadAnimeInfoCoroutineFunc _func)
		{
			string[] files = this.FindAllAssetName(_bundlePath, _regex);
			if (files.IsNullOrEmpty<string>())
			{
				yield break;
			}
			string checkKey = _regex.Split(new char[]
			{
				'_'
			})[0].ToLower();
			SortedDictionary<int, SortedDictionary<int, SortedDictionary<int, string>>> sortDic = new SortedDictionary<int, SortedDictionary<int, SortedDictionary<int, string>>>();
			for (int i = 0; i < files.Length; i++)
			{
				if (files[i].Split(new char[]
				{
					'_'
				})[0].ToLower().CompareTo(checkKey) == 0)
				{
					Match match = Regex.Match(files[i], _regex, RegexOptions.IgnoreCase);
					int key = int.Parse(match.Groups[1].Value);
					int key2 = int.Parse(match.Groups[2].Value);
					int key3 = int.Parse(match.Groups[3].Value);
					if (!sortDic.ContainsKey(key))
					{
						sortDic.Add(key, new SortedDictionary<int, SortedDictionary<int, string>>());
					}
					if (!sortDic[key].ContainsKey(key2))
					{
						sortDic[key].Add(key2, new SortedDictionary<int, string>());
					}
					sortDic[key][key2].Add(key3, files[i]);
				}
			}
			foreach (KeyValuePair<int, SortedDictionary<int, SortedDictionary<int, string>>> g in sortDic)
			{
				foreach (KeyValuePair<int, SortedDictionary<int, string>> c in g.Value)
				{
					foreach (KeyValuePair<int, string> v in c.Value)
					{
						_func(this.LoadExcelData(_bundlePath, v.Value), _dic);
						if (this.waitTime.isOver)
						{
							yield return null;
							this.waitTime.Next();
						}
					}
				}
			}
			yield break;
		}

		// Token: 0x06001FD0 RID: 8144 RVA: 0x000C571C File Offset: 0x000C391C
		private void LoadAnimeLoadInfo(ExcelData _ed, Dictionary<int, Dictionary<int, Dictionary<int, Info.AnimeLoadInfo>>> _dic)
		{
			if (_ed == null)
			{
				return;
			}
			foreach (List<string> list in from v in _ed.list.Skip(2)
			select v.list)
			{
				int num = 0;
				Info.AnimeLoadInfo animeLoadInfo = new Info.AnimeLoadInfo();
				int key = -1;
				if (int.TryParse(list[num++], out key))
				{
					int key2 = int.Parse(list[num++]);
					int key3 = int.Parse(list[num++]);
					animeLoadInfo.name = list[num++];
					animeLoadInfo.bundlePath = list[num++];
					animeLoadInfo.fileName = list[num++];
					animeLoadInfo.clip = list[num++];
					bool flag = bool.Parse(list[num++]);
					if (flag)
					{
						float value = 0f;
						bool flag2 = true;
						for (int i = 0; i < 2; i++)
						{
							for (int j = 0; j < 3; j++)
							{
								flag2 &= float.TryParse(list[num++], out value);
								if (flag2)
								{
									animeLoadInfo.scale[i][j] = value;
								}
							}
						}
						animeLoadInfo.isScale = flag2;
						while (num + 4 <= list.Count)
						{
							Info.OptionItemInfo optionItemInfo = new Info.OptionItemInfo();
							optionItemInfo.no = int.Parse(list[num++]);
							optionItemInfo.bundlePath = list[num++];
							optionItemInfo.fileName = list[num++];
							optionItemInfo.parentageInfo = new Info.ParentageInfo[1];
							optionItemInfo.parentageInfo[0] = new Info.ParentageInfo
							{
								parent = list[num++]
							};
							animeLoadInfo.listOptions.Add(optionItemInfo);
						}
					}
					if (!_dic.ContainsKey(key2))
					{
						_dic.Add(key2, new Dictionary<int, Dictionary<int, Info.AnimeLoadInfo>>());
					}
					if (!_dic[key2].ContainsKey(key3))
					{
						_dic[key2].Add(key3, new Dictionary<int, Info.AnimeLoadInfo>());
					}
					_dic[key2][key3][key] = animeLoadInfo;
				}
			}
		}

		// Token: 0x06001FD1 RID: 8145 RVA: 0x000C59B8 File Offset: 0x000C3BB8
		private void LoadHAnimeLoadInfo(ExcelData _ed, Dictionary<int, Dictionary<int, Dictionary<int, Info.AnimeLoadInfo>>> _dic)
		{
			if (_ed == null)
			{
				return;
			}
			foreach (List<string> list in from v in _ed.list.Skip(2)
			select v.list)
			{
				int num = 0;
				Info.AnimeLoadInfo animeLoadInfo = new Info.AnimeLoadInfo();
				animeLoadInfo.isHAnime = true;
				animeLoadInfo.isScale = false;
				int key = 0;
				if (int.TryParse(list[num++], out key))
				{
					int key2 = int.Parse(list[num++]);
					int key3 = int.Parse(list[num++]);
					animeLoadInfo.name = list[num++];
					animeLoadInfo.bundlePath = list[num++];
					animeLoadInfo.fileName = list[num++];
					animeLoadInfo.clip = list[num++];
					animeLoadInfo.isBreastLayer = bool.Parse(list[num++]);
					animeLoadInfo.dynamic[0] = !bool.Parse(list[num++]);
					animeLoadInfo.dynamic[1] = !bool.Parse(list[num++]);
					animeLoadInfo.isMotion = bool.Parse(list[num++]);
					bool flag = bool.Parse(list[num++]);
					if (flag)
					{
						while (num + 4 <= list.Count)
						{
							Info.OptionItemInfo optionItemInfo = new Info.OptionItemInfo();
							optionItemInfo.no = int.Parse(list[num++]);
							optionItemInfo.bundlePath = list[num++];
							optionItemInfo.fileName = list[num++];
							optionItemInfo.parentageInfo = this.AnalysisParentageInfo(list[num++]);
							animeLoadInfo.listOptions.Add(optionItemInfo);
						}
					}
					if (!_dic.ContainsKey(key2))
					{
						_dic.Add(key2, new Dictionary<int, Dictionary<int, Info.AnimeLoadInfo>>());
					}
					if (!_dic[key2].ContainsKey(key3))
					{
						_dic[key2].Add(key3, new Dictionary<int, Info.AnimeLoadInfo>());
					}
					_dic[key2][key3][key] = animeLoadInfo;
				}
			}
		}

		// Token: 0x06001FD2 RID: 8146 RVA: 0x000C5C38 File Offset: 0x000C3E38
		private void LoadHandAnimeInfo(string _bundlePath, string _regex, Dictionary<int, Info.HandAnimeInfo>[] _dic)
		{
			string[] array = this.FindAllAssetName(_bundlePath, _regex);
			if (array.IsNullOrEmpty<string>())
			{
				return;
			}
			string strB = _regex.Split(new char[]
			{
				'_'
			})[0].ToLower();
			SortedDictionary<int, SortedDictionary<int, string>> sortedDictionary = new SortedDictionary<int, SortedDictionary<int, string>>();
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i].Split(new char[]
				{
					'_'
				})[0].ToLower().CompareTo(strB) == 0)
				{
					Match match = Regex.Match(array[i], _regex, RegexOptions.IgnoreCase);
					int key = int.Parse(match.Groups[1].Value);
					int key2 = int.Parse(match.Groups[2].Value);
					if (!sortedDictionary.ContainsKey(key))
					{
						sortedDictionary.Add(key, new SortedDictionary<int, string>());
					}
					sortedDictionary[key].Add(key2, array[i]);
				}
			}
			foreach (KeyValuePair<int, SortedDictionary<int, string>> keyValuePair in sortedDictionary)
			{
				foreach (KeyValuePair<int, string> keyValuePair2 in keyValuePair.Value)
				{
					this.LoadHandAnimeInfo(this.LoadExcelData(_bundlePath, keyValuePair2.Value), _dic[keyValuePair.Key]);
				}
			}
		}

		// Token: 0x06001FD3 RID: 8147 RVA: 0x000C5DCC File Offset: 0x000C3FCC
		private void LoadHandAnimeInfo(ExcelData _ed, Dictionary<int, Info.HandAnimeInfo> _dic)
		{
			if (_ed == null)
			{
				return;
			}
			foreach (List<string> list in from v in _ed.list.Skip(2)
			select v.list)
			{
				int num = 0;
				int key = int.Parse(list[num++]);
				_dic[key] = new Info.HandAnimeInfo
				{
					name = list[num++],
					bundlePath = list[num++],
					fileName = list[num++],
					clip = list[num++]
				};
			}
		}

		// Token: 0x06001FD4 RID: 8148 RVA: 0x000C5EC0 File Offset: 0x000C40C0
		private IEnumerator LoadVoiceLoadInfoCoroutine(string _bundlePath, string _regex)
		{
			string[] files = this.FindAllAssetName(_bundlePath, _regex);
			if (files.IsNullOrEmpty<string>())
			{
				yield break;
			}
			string checkKey = _regex.Split(new char[]
			{
				'_'
			})[0].ToLower();
			SortedDictionary<int, SortedDictionary<int, SortedDictionary<int, string>>> sortDic = new SortedDictionary<int, SortedDictionary<int, SortedDictionary<int, string>>>();
			for (int i = 0; i < files.Length; i++)
			{
				if (files[i].Split(new char[]
				{
					'_'
				})[0].ToLower().CompareTo(checkKey) == 0)
				{
					Match match = Regex.Match(files[i], _regex, RegexOptions.IgnoreCase);
					int key = int.Parse(match.Groups[1].Value);
					int key2 = int.Parse(match.Groups[2].Value);
					int key3 = int.Parse(match.Groups[3].Value);
					if (!sortDic.ContainsKey(key))
					{
						sortDic.Add(key, new SortedDictionary<int, SortedDictionary<int, string>>());
					}
					if (!sortDic[key].ContainsKey(key2))
					{
						sortDic[key].Add(key2, new SortedDictionary<int, string>());
					}
					sortDic[key][key2].Add(key3, files[i]);
				}
			}
			foreach (KeyValuePair<int, SortedDictionary<int, SortedDictionary<int, string>>> g in sortDic)
			{
				foreach (KeyValuePair<int, SortedDictionary<int, string>> c in g.Value)
				{
					foreach (KeyValuePair<int, string> v in c.Value)
					{
						this.LoadVoiceLoadInfo(this.LoadExcelData(_bundlePath, v.Value));
						if (this.waitTime.isOver)
						{
							yield return null;
							this.waitTime.Next();
						}
					}
				}
			}
			yield break;
		}

		// Token: 0x06001FD5 RID: 8149 RVA: 0x000C5EEC File Offset: 0x000C40EC
		private void LoadVoiceLoadInfo(ExcelData _ed)
		{
			foreach (List<string> list in from v in _ed.list.Skip(2)
			select v.list)
			{
				this.LoadVoiceLoadInfo(list);
			}
		}

		// Token: 0x06001FD6 RID: 8150 RVA: 0x000C5F70 File Offset: 0x000C4170
		private void LoadSoundLoadInfo(ExcelData _ed, Dictionary<int, Info.LoadCommonInfo> _dic)
		{
			if (_ed == null)
			{
				return;
			}
			foreach (List<string> list in from v in _ed.list.Skip(1)
			select v.list)
			{
				int num = 0;
				int key = int.Parse(list[num++]);
				_dic[key] = new Info.LoadCommonInfo
				{
					name = list[num++],
					bundlePath = list[num++],
					fileName = list[num++]
				};
			}
		}

		// Token: 0x06001FD7 RID: 8151 RVA: 0x000C6050 File Offset: 0x000C4250
		private void LoadMapLoadInfo(ExcelData _ed, Dictionary<int, Info.LoadCommonInfo> _dic)
		{
			if (_ed == null)
			{
				return;
			}
			foreach (List<string> list in from v in _ed.list.Skip(1)
			select v.list)
			{
				int num = 0;
				int key = int.Parse(list[num++]);
				_dic[key] = new Info.LoadCommonInfo
				{
					name = list[num++],
					bundlePath = list[num++],
					fileName = list[num++],
					manifest = list.SafeGet(num++)
				};
			}
		}

		// Token: 0x06001FD8 RID: 8152 RVA: 0x000C6144 File Offset: 0x000C4344
		private void LoadExpressionInfo(ExcelData _ed, Dictionary<int, Info.ExpressionInfo> _dic)
		{
			if (_ed == null)
			{
				return;
			}
			foreach (List<string> list in from v in _ed.list.Skip(1)
			select v.list)
			{
				int num = 0;
				int key = int.Parse(list[num++]);
				_dic[key] = new Info.ExpressionInfo
				{
					clip = list[num++],
					name = list[num++]
				};
			}
		}

		// Token: 0x06001FD9 RID: 8153 RVA: 0x000C6214 File Offset: 0x000C4414
		private void LoadSkyLoadInfo(ExcelData _ed, Dictionary<int, Info.LoadCommonInfo> _dic)
		{
			if (_ed == null)
			{
				return;
			}
			foreach (List<string> list in from v in _ed.list.Skip(1)
			select v.list)
			{
				int num = 0;
				int key = int.Parse(list[num++]);
				_dic[key] = new Info.LoadCommonInfo
				{
					name = list[num++],
					bundlePath = list[num++],
					fileName = list[num++],
					manifest = list.SafeGet(num++)
				};
			}
		}

		// Token: 0x06001FDA RID: 8154 RVA: 0x000C6308 File Offset: 0x000C4508
		protected override void Awake()
		{
			if (!base.CheckInstance())
			{
				return;
			}
			UnityEngine.Object.DontDestroyOnLoad(base.gameObject);
			this.isLoadList = false;
		}

		// Token: 0x0400215D RID: 8541
		public Dictionary<int, Info.BoneInfo> dicFemaleBoneInfo = new Dictionary<int, Info.BoneInfo>();

		// Token: 0x0400215E RID: 8542
		public Dictionary<int, Info.BoneInfo> dicMaleBoneInfo = new Dictionary<int, Info.BoneInfo>();

		// Token: 0x0400215F RID: 8543
		public Dictionary<int, string> dicItemGroup = new Dictionary<int, string>();

		// Token: 0x04002160 RID: 8544
		public Dictionary<int, Info.ItemLoadInfo> dicItemLoadInfo = new Dictionary<int, Info.ItemLoadInfo>();

		// Token: 0x04002161 RID: 8545
		public Dictionary<int, Info.ItemLoadInfo> dicHItemLoadInfo = new Dictionary<int, Info.ItemLoadInfo>();

		// Token: 0x04002162 RID: 8546
		private ExcelData m_AccessoryPoint;

		// Token: 0x04002163 RID: 8547
		private ExcelData m_AccessoryPointGroup;

		// Token: 0x04002164 RID: 8548
		public Dictionary<int, Info.LightLoadInfo> dicLightLoadInfo = new Dictionary<int, Info.LightLoadInfo>();

		// Token: 0x04002165 RID: 8549
		public Dictionary<int, Info.GroupInfo> dicFAGroupCategory = new Dictionary<int, Info.GroupInfo>();

		// Token: 0x04002166 RID: 8550
		public Dictionary<int, Info.GroupInfo> dicMAGroupCategory = new Dictionary<int, Info.GroupInfo>();

		// Token: 0x04002167 RID: 8551
		public Dictionary<int, Dictionary<int, Dictionary<int, Info.AnimeLoadInfo>>> dicFemaleAnimeLoadInfo = new Dictionary<int, Dictionary<int, Dictionary<int, Info.AnimeLoadInfo>>>();

		// Token: 0x04002168 RID: 8552
		public Dictionary<int, Dictionary<int, Dictionary<int, Info.AnimeLoadInfo>>> dicMaleAnimeLoadInfo = new Dictionary<int, Dictionary<int, Dictionary<int, Info.AnimeLoadInfo>>>();

		// Token: 0x04002169 RID: 8553
		public Dictionary<int, Info.HandAnimeInfo>[] dicFemaleHandAnime = new Dictionary<int, Info.HandAnimeInfo>[]
		{
			new Dictionary<int, Info.HandAnimeInfo>(),
			new Dictionary<int, Info.HandAnimeInfo>()
		};

		// Token: 0x0400216A RID: 8554
		public Dictionary<int, Info.HandAnimeInfo>[] dicMaleHandAnime = new Dictionary<int, Info.HandAnimeInfo>[]
		{
			new Dictionary<int, Info.HandAnimeInfo>(),
			new Dictionary<int, Info.HandAnimeInfo>()
		};

		// Token: 0x0400216B RID: 8555
		public Dictionary<int, Info.GroupInfo> dicVoiceGroupCategory = new Dictionary<int, Info.GroupInfo>();

		// Token: 0x0400216C RID: 8556
		public Dictionary<int, Dictionary<int, Dictionary<int, Info.LoadCommonInfo>>> dicVoiceLoadInfo = new Dictionary<int, Dictionary<int, Dictionary<int, Info.LoadCommonInfo>>>();

		// Token: 0x0400216D RID: 8557
		public Dictionary<int, Info.LoadCommonInfo> dicBGMLoadInfo = new Dictionary<int, Info.LoadCommonInfo>();

		// Token: 0x0400216E RID: 8558
		public Dictionary<int, Info.LoadCommonInfo> dicENVLoadInfo = new Dictionary<int, Info.LoadCommonInfo>();

		// Token: 0x0400216F RID: 8559
		public Dictionary<int, Info.LoadCommonInfo> dicMapLoadInfo = new Dictionary<int, Info.LoadCommonInfo>();

		// Token: 0x04002170 RID: 8560
		public Dictionary<int, Info.ExpressionInfo> dicFemaleEye = new Dictionary<int, Info.ExpressionInfo>();

		// Token: 0x04002171 RID: 8561
		public Dictionary<int, Info.ExpressionInfo> dicFemaleMouth = new Dictionary<int, Info.ExpressionInfo>();

		// Token: 0x04002172 RID: 8562
		public Dictionary<int, Info.ExpressionInfo> dicMaleEye = new Dictionary<int, Info.ExpressionInfo>();

		// Token: 0x04002173 RID: 8563
		public Dictionary<int, Info.ExpressionInfo> dicMaleMouth = new Dictionary<int, Info.ExpressionInfo>();

		// Token: 0x04002174 RID: 8564
		public Dictionary<int, Info.LoadCommonInfo> dicSkyLoadInfo = new Dictionary<int, Info.LoadCommonInfo>();

		// Token: 0x04002175 RID: 8565
		private Info.FileCheck fileCheck;

		// Token: 0x04002177 RID: 8567
		private Info.WaitTime waitTime;

		// Token: 0x04002179 RID: 8569
		[CompilerGenerated]
		private static Func<string, string> callback0;

		// Token: 0x020004DC RID: 1244
		public class FileInfo
		{
			// Token: 0x0400218A RID: 8586
			public string manifest = string.Empty;

			// Token: 0x0400218B RID: 8587
			public string bundlePath = string.Empty;

			// Token: 0x0400218C RID: 8588
			public string fileName = string.Empty;
		}

		// Token: 0x020004DD RID: 1245
		public class LoadCommonInfo : Info.FileInfo
		{
			// Token: 0x0400218D RID: 8589
			public string name = string.Empty;
		}

		// Token: 0x020004DE RID: 1246
		public class BoneInfo
		{
			// Token: 0x0400218E RID: 8590
			public int no;

			// Token: 0x0400218F RID: 8591
			public string bone = string.Empty;

			// Token: 0x04002190 RID: 8592
			public string name = string.Empty;

			// Token: 0x04002191 RID: 8593
			public int group = -1;

			// Token: 0x04002192 RID: 8594
			public int level;
		}

		// Token: 0x020004DF RID: 1247
		public class ItemLoadInfo : Info.LoadCommonInfo
		{
			// Token: 0x04002193 RID: 8595
			public int no;

			// Token: 0x04002194 RID: 8596
			public int group;

			// Token: 0x04002195 RID: 8597
			public string childRoot;

			// Token: 0x04002196 RID: 8598
			public bool isAnime;

			// Token: 0x04002197 RID: 8599
			public bool isColor;

			// Token: 0x04002198 RID: 8600
			public string[] colorTarget;

			// Token: 0x04002199 RID: 8601
			public bool isColor2;

			// Token: 0x0400219A RID: 8602
			public string[] color2Target;

			// Token: 0x0400219B RID: 8603
			public bool isScale;

			// Token: 0x0400219C RID: 8604
			public List<string> bones;
		}

		// Token: 0x020004E0 RID: 1248
		public class LightLoadInfo : Info.LoadCommonInfo
		{
			// Token: 0x0400219D RID: 8605
			public int no;

			// Token: 0x0400219E RID: 8606
			public Info.LightLoadInfo.Target target;

			// Token: 0x020004E1 RID: 1249
			public enum Target
			{
				// Token: 0x040021A0 RID: 8608
				All,
				// Token: 0x040021A1 RID: 8609
				Chara,
				// Token: 0x040021A2 RID: 8610
				Map
			}
		}

		// Token: 0x020004E2 RID: 1250
		public class ParentageInfo
		{
			// Token: 0x040021A3 RID: 8611
			public string parent = string.Empty;

			// Token: 0x040021A4 RID: 8612
			public string child = string.Empty;
		}

		// Token: 0x020004E3 RID: 1251
		public class OptionItemInfo : Info.FileInfo
		{
			// Token: 0x040021A5 RID: 8613
			public int no = -1;

			// Token: 0x040021A6 RID: 8614
			public Info.ParentageInfo[] parentageInfo;
		}

		// Token: 0x020004E4 RID: 1252
		public class AnimeLoadInfo : Info.LoadCommonInfo
		{
			// Token: 0x040021A7 RID: 8615
			public string clip = string.Empty;

			// Token: 0x040021A8 RID: 8616
			public bool isScale;

			// Token: 0x040021A9 RID: 8617
			public Vector3[] scale = new Vector3[]
			{
				Vector3.one,
				Vector3.one
			};

			// Token: 0x040021AA RID: 8618
			public bool isHAnime;

			// Token: 0x040021AB RID: 8619
			public bool isBreastLayer;

			// Token: 0x040021AC RID: 8620
			public bool[] dynamic = new bool[]
			{
				true,
				true
			};

			// Token: 0x040021AD RID: 8621
			public bool isMotion;

			// Token: 0x040021AE RID: 8622
			public List<Info.OptionItemInfo> listOptions = new List<Info.OptionItemInfo>();
		}

		// Token: 0x020004E5 RID: 1253
		public class GroupInfo
		{
			// Token: 0x040021AF RID: 8623
			public string name = string.Empty;

			// Token: 0x040021B0 RID: 8624
			public Dictionary<int, string> dicCategory = new Dictionary<int, string>();
		}

		// Token: 0x020004E6 RID: 1254
		public class HandAnimeInfo : Info.LoadCommonInfo
		{
			// Token: 0x040021B1 RID: 8625
			public string clip = string.Empty;
		}

		// Token: 0x020004E7 RID: 1255
		public class ExpressionInfo
		{
			// Token: 0x040021B2 RID: 8626
			public string clip = string.Empty;

			// Token: 0x040021B3 RID: 8627
			public string name = string.Empty;
		}

		// Token: 0x020004E8 RID: 1256
		private class FileCheck
		{
			// Token: 0x06001FF7 RID: 8183 RVA: 0x000C653C File Offset: 0x000C473C
			public FileCheck()
			{
				this.dicConfirmed = new Dictionary<string, bool>();
			}

			// Token: 0x06001FF8 RID: 8184 RVA: 0x000C6550 File Offset: 0x000C4750
			public bool Check(string _path, bool _force = false)
			{
				bool flag = false;
				if (this.dicConfirmed.TryGetValue(_path, out flag))
				{
					return flag;
				}
				flag = ((_force || !AssetBundleCheck.IsSimulation) && File.Exists(AssetBundleManager.BaseDownloadingURL + _path));
				this.dicConfirmed.Add(_path, flag);
				return flag;
			}

			// Token: 0x040021B4 RID: 8628
			private Dictionary<string, bool> dicConfirmed;
		}

		// Token: 0x020004E9 RID: 1257
		private class WaitTime
		{
			// Token: 0x06001FF9 RID: 8185 RVA: 0x000C65AC File Offset: 0x000C47AC
			public WaitTime()
			{
				this.Next();
			}

			// Token: 0x170003A4 RID: 932
			// (get) Token: 0x06001FFA RID: 8186 RVA: 0x000C65BC File Offset: 0x000C47BC
			public bool isOver
			{
				get
				{
					return Time.realtimeSinceStartup >= this.nextFrameTime;
				}
			}

			// Token: 0x06001FFB RID: 8187 RVA: 0x000C65D0 File Offset: 0x000C47D0
			public void Next()
			{
				this.nextFrameTime = Time.realtimeSinceStartup + 0.03f;
			}

			// Token: 0x040021B5 RID: 8629
			private const float intervalTime = 0.03f;

			// Token: 0x040021B6 RID: 8630
			private float nextFrameTime;
		}

		// Token: 0x020004EA RID: 1258
		// (Invoke) Token: 0x06001FFD RID: 8189
		private delegate void LoadAnimeInfoCoroutineFunc(ExcelData _ed, Dictionary<int, Dictionary<int, Dictionary<int, Info.AnimeLoadInfo>>> _dic);
	}
}
